import java.io.PrintStream;
import java.util.Arrays;

public class Test {

public  static  int fun(int n) {

    if(n==1) {
        return 1;
    }
    return n*fun(n-1);
}

public  static int fun1(int a) {
    if(a==1) {
        return 1;
    }
    return a+fun1(a-1);
}

public static void fun3(int n) {
    if(n<=9) {
        System.out.print(n+" ");
    } else {
       fun3(n/10);
        System.out.print(n%10+" ");
    }
}
public static int fun4(int n) {
    if(n<=9) {
        return n;
    } else {
      return n%10+fun4(n/10);
    }
}
public static int fun5(int n) {
    if(n==1||n==2) {
        return 1;
    }else {
        return fun5(n-1)+fun5(n-2);
    }
}
public static void prin(char pos1,char pos2) {
    System.out.print(pos1+"->"+pos2+" ");
}
//a->c 一层
//a->b  a->c b->c 两层
//a->c  a->b c->b a->c b->a b->c a->c
    public  static  void fun7(int n,char pos1,char pos2,char pos3) {
    if(n==1) {
        prin(pos1,pos3);
    }else {
        fun7(n-1,pos1,pos3,pos2);
        prin(pos1,pos3);
        fun7(n-1,pos2,pos1,pos3);
    }
}

public static String  printArray(int[]arr) {
    String p="[";
    for (int i = 0; i <arr.length ; i++) {
       p=p+arr[i];
       p+=" ";
    }
    p+="]";
    return p;
}
    public static void main(String[] args) {
        int []arr =new int[100];
        for (int i = 1; i <=100 ; i++) {
            arr[i-1]=i;
        }
        System.out.println(printArray(arr));
        //System.out.println(Arrays.toString(arr));
    }
    public static void main11(String[] args) {
        //创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100
        int []arr =new int[100];
        for (int i = 1; i <=100 ; i++) {
            arr[i-1]=i;
        }
        for(int x:arr){
            System.out.print(x+" ");
        }
    }
    public static void main9(String[] args) {
        //递归求解汉诺塔问题
        fun7(3,'a','b','c');
    }
    public static void main6(String[] args) {
        //递归求斐波那契数列的第 N 项
        System.out.println(fun5(10));
    }
   // 1 1 2 3 5 8
    public static void main5(String[] args) {
        System.out.println(fun4(1234));
    }
    public static void main3(String[] args) {
        //递归打印数字的每一位
            fun3(1234);
    }
    public static void main2(String[] args) {
        //递归求 1 + 2 + 3 + ... + 10
        System.out.println(fun1(10));
    }
    public static void main1(String[] args) {
        //递归求 N 的阶乘
        System.out.println(fun(8));
    }
   // public static void main6(String[] args) {
//        int a=10;
//        long b=100L;
//        b=a;//int类型转换为long类型，数据范围由小到大，
//        a=(int)b;//long类型转换为int类型，数据范围由大到小，需要强转否则编译失败
//
//        float c=3.14f;
//        double d=6.66;
//        d=c;//float类型转换为double类型，数据范围由小到大，
//        c=(float)d;//double类型转换为float类型，数据范围由大到小，需要强转否则编译失败
//
//        a=d;//报错，类型不兼容，需要强转
//        a=(int)d;//int没有double表示的范围大，需要强转，小数点后面的值全部丢弃
//        b=a;//int类型转化为double类型，数据范围由小变大
//
//        byte b1=100;//100默认为100，没有超过byte范围（隐式转换）
//        byte b2=(byte)257;//257默认为int,超过byte范围，需要显式转换否则报错
//
//        boolean flag=true;
//        a=flag;//编译失败类型不兼容
//        flag=a;//编译失败类型不兼容
 //   }
//    public static void main5(String[] args) {
//        byte a=127;
//        byte b=128;
//
//    }
//    public static void main4(String[] args) {
//        byte a=10;
//        byte b=20;
//        byte c=(a+b);

    //}
   // public static void main3(String[] args) {

//        float a=3.14f;
//        float b=66.6f;
//        double c=a+b;



//        byte a=10;
//        byte b=20;
//        int c=a+b;
//
//
//    }
//    public static void main2(String[] args) {
//        byte a=10;//byte类型
//        byte b=20;//byte类型
//        byte c=0;//byte类型
//        int d=20;//int整形
//
//
////        a=c+d;//我们将一个整形和一个byte类型的值相加赋值给a(byte类型)
////        a=c+(byte)d;  //方法一
////        a= (byte) (c+d);//方法一升级版
////        int e=c+d;    //方法二
//
////        c=a+b;//将两个byte类型的值相加赋值给一个byte类型
//
//    }
//    public static void main1(String[] args) {
//        int a=4;//创建一个整形变量a
//        long b=8L;//创建一个长整型变量b(java中没有longlong类型)
//        a=b;
//    }
}
